graphology-utils

What is graphology-utils?

The graphology-utils npm package provides a set of utility functions for working with graphology, a JavaScript library for manipulating and analyzing graphs. These utilities help in performing common graph operations such as traversal, manipulation, and analysis.

What are graphology-utils's main functionalities?

Graph Traversal

This feature allows you to traverse through all nodes in a graph and perform operations on them. The code sample demonstrates how to use the `forEachNode` utility to log each node and its attributes.

const { forEachNode } = require('graphology-utils');
const Graph = require('graphology');

const graph = new Graph();
graph.addNode('John');
graph.addNode('Martha');
graph.addEdge('John', 'Martha');

forEachNode(graph, (node, attributes) => {
  console.log(node, attributes);
});

Graph Manipulation

This feature allows you to merge multiple graphs into one. The code sample demonstrates how to use the `mergeGraphs` utility to combine two graphs into a single graph.

const { mergeGraphs } = require('graphology-utils');
const Graph = require('graphology');

const graph1 = new Graph();
graph1.addNode('Alice');
const graph2 = new Graph();
graph2.addNode('Bob');

const mergedGraph = mergeGraphs(graph1, graph2);
console.log(mergedGraph.nodes());

Graph Analysis

This feature allows you to perform analysis on the graph, such as calculating the degree of a node. The code sample demonstrates how to use the `degree` utility to find the degree of a node named 'Alice'.

const { degree } = require('graphology-utils');
const Graph = require('graphology');

const graph = new Graph();
graph.addNode('Alice');
graph.addNode('Bob');
graph.addEdge('Alice', 'Bob');

const aliceDegree = degree(graph, 'Alice');
console.log(aliceDegree);

Other packages similar to graphology-utils

cytoscape

Cytoscape is a graph theory library for analysis and visualization. It provides a rich set of features for graph manipulation and analysis, similar to graphology-utils, but also includes advanced visualization capabilities.

d3-graphviz

d3-graphviz is a library for rendering graphs using Graphviz and D3.js. While it focuses more on visualization, it also provides utilities for graph manipulation and analysis, making it somewhat comparable to graphology-utils.

sigma

Sigma is a JavaScript library dedicated to graph drawing. It provides functionalities for graph manipulation and visualization, similar to graphology-utils, but with a stronger emphasis on rendering and interaction.

README

Graphology Utils

Miscellaneous utility functions to be used with graphology.

Installation

npm install graphology-utils

Usage

• #.inferType
• #.isGraph
• #.isGraphConstructor
• #.mergeClique
• #.mergeCycle
• #.mergePath
• #.mergeStar
• #.subGraph

#.inferType

Function returning the inferred type of the given graph. This function is useful to check whether a given mixed graph is in fact a mere directed or undirected graph based on its actual edges.

import Graph from 'graphology';
import {inferType} from 'graphology-utils';
// Alternatively, if you want to only load the relevant code:
import inferType from 'graphology-utils/infer-type';

const graph = new Graph();
graph.addUndirectedEdge(1, 2);

inferType(graph);
>>> 'directed'

#.isGraph

Function returning whether the given value is a graphology implementation's instance.

import Graph from 'graphology';
import {isGraph} from 'graphology-utils';
// Alternatively, if you want to only load the relevant code:
import isGraph from 'graphology-utils/is-graph';

const graph = new Graph();

isGraph(graph);
>>> true

isGraph(45);
>>> false

isGraph({hello: 'world'});
>>> false

Arguments

• value any: value to test.

#.isGraphConstructor

Function returning whether the given value is a graphology constructor.

import Graph from 'graphology';
import {isGraphConstructor} from 'graphology-utils';
// Alternatively, if you want to only load the relevant code:
import isGraphConstructor from 'graphology-utils/is-graph-constructor';

isGraphConstructor(Graph);
>>> true

isGraphConstructor(45);
>>> false

isGraphConstructor(new Graph());
>>> false

Arguments

• value any: value to test.

#.mergeClique

Function adding a clique to the given graph.

import Graph from 'graphology';
import {mergeClique} from 'graphology-utils';
// Alternatively, if you want to only load the relevant code:
import mergeClique from 'graphology-utils/merge-clique';

const graph = new Graph();

mergeClique(graph, [1, 2, 3]);
graph.edges().map(e => graph.extremities(e));
>>> [[1, 2], [1, 3], [2, 3]]

#.mergeCycle

Function adding a cycle to the given graph.

import Graph from 'graphology';
import {mergeCycle} from 'graphology-utils';
// Alternatively, if you want to only load the relevant code:
import mergeCycle from 'graphology-utils/merge-cycle';

const graph = new Graph();

mergeCycle(graph, [1, 2, 3, 4, 5]);
graph.edges().map(e => graph.extremities(e));
>>> [[1, 2], [2, 3], [3, 4], [4, 5], [5, 1]]

Arguments

• graph Graph: target graph.
• cycle array: array of nodes representing the cycle to add.

#.mergePath

Function adding a path to the given graph.

import Graph from 'graphology';
import {mergePath} from 'graphology-utils';
// Alternatively, if you want to only load the relevant code:
import mergePath from 'graphology-utils/merge-path';

const graph = new Graph();

mergePath(graph, [1, 2, 3, 4, 5]);
graph.edges().map(e => graph.extremities(e));
>>> [[1, 2], [2, 3], [3, 4], [4, 5]]

Arguments

• graph Graph: target graph.
• path array: array of nodes representing the path to add.

#.mergeStar

Function adding a star to the given graph.

import Graph from 'graphology';
import {mergeStar} from 'graphology-utils';
// Alternatively, if you want to only load the relevant code:
import mergeStar from 'graphology-utils/merge-star';

const graph = new Graph();

mergeStar(graph, [1, 2, 3, 4, 5]);
graph.edges().map(e => graph.extremities(e));
>>> [[1, 2], [1, 3], [1, 4], [1, 5]]

Arguments

• graph Graph: target graph.
• star array: array of nodes representing the star to add.

#.subGraph

Function returning the subgraph corresponding to the given list of nodes.

import Graph from 'graphology';
import {subGraph} from 'graphology-utils';
// Alternatively, if you want to only load the relevant code:
import subGraph from 'graphology-utils/subgraph';

const graph = new Graph();

graph.addNode('Dale');
graph.addNode('Laura');
graph.addNode('Norma');
graph.addNode('Shelly');
graph.addEdge('Dale', 'Laura');
graph.addEdge('Dale', 'Norma');
graph.addEdge('Shelly', 'Laura');
graph.addUndirectedEdge('Norma', 'Shelly');

subGraphResult = subGraph(graph, ['Dale', 'Laura']);
subGraphResult.nodes();
>>> [ 'Dale', 'Laura' ]
subGraphResult.forEachEdge(
  (edge, attributes, source, target) => {
    console.log(`Edge from ${source} to ${target}`);
});
>>> 'Edge from Dale to Laura'

Arguments

• graph Graph: source graph.
• nodes array|Set|function: the array, set or function defining the subgraph's nodes.